package cn.ducis.macaw.core.staticflies.file;

import java.io.*;
import java.nio.file.Files;
import java.util.Map;

/**
 * @author Yellow
 * @version 1.0
 */
public class FileParse {
	private static final int DEFALUT_SIZE = 1024;

	/**
	 * 将指定路径的文件信息读取到一个字节数组中
	 * 
	 * @param path
	 * @return 存储信息的字节数组
	 */
	public static byte[] fileToArray(String path) {
		InputStream inputStream = null;
		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
		try {
			inputStream = new FileInputStream(path);
			byte[] temp = new byte[DEFALUT_SIZE];
			int len = -1;// 初值为-1可以防止空文件
			// 每次循环读取文件信息到暂存数组中，直到读完
			while ((len = inputStream.read(temp)) != -1) {
				// 每次循环将暂存数组中的信息写到输出流中
				byteArrayOutputStream.write(temp, 0, len);
			}
			// 将流中数据转成字节数组返回
			return byteArrayOutputStream.toByteArray();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				// 关闭流
				inputStream.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	/**
	 * 将指定数组中存放的文件信息写到指定路径的文件中（文本文件）
	 * 
	 * @param array
	 *            存放信息的数组
	 * @param path
	 *            输出文件的存放路径
	 */
	public static void writeFile(byte[] array, String path) {
		// 创建一个字节输出流
		DataOutputStream dataOutputStream = null;
		try {
			dataOutputStream = new DataOutputStream(new FileOutputStream(path));
			// 将字节数组信息写到基础输出流中
			dataOutputStream.write(array);
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				// 关闭流
				dataOutputStream.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 将指定路径文本文件存储文件信息中指定段的信息存到数组
	 * 
	 * @param path
	 *            存放文件信息的文件路径
	 * @param start
	 *            开始位置
	 * @param end
	 *            结束位置
	 * @return 存放文件信息的字节数组
	 */
	public static byte[] fileIn(String path, int start, int end) {
		DataInputStream dataInputStream = null;
		try {
			dataInputStream = new DataInputStream(new FileInputStream(path));
			// 创建一个小文件大小的数组
			byte[] b = new byte[end - start];
			// 从start开始读取end - start个字节信息放入数组b
			dataInputStream.skipBytes(start);		
			dataInputStream.read(b, 0, end - start);
			return b;
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				// 关闭流
				dataInputStream.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
	}
	
	/**
	 * 将指定路径文本文件信息输出到数组
	 * 
	 * @param path
	 * @return
	 */
	@Deprecated
	public static byte[] fileIn(String path) {
		DataInputStream dataInputStream = null;
		try {
			dataInputStream = new DataInputStream(new FileInputStream(path));
			byte[] b = new byte[dataInputStream.available()];
			dataInputStream.read(b);
			return b;
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				dataInputStream.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	/**
	 * 将指定数组中存放的文件信息输出到指定路径的图片中
	 * 
	 * @param file
	 *            放文件信息的数组
	 * @param path
	 *            输出路径
	 */
	public static void fileOut(byte[] file, String path) {
		// 创建一个字节输出流
		OutputStream outputStream = null;
		try {
			outputStream = new FileOutputStream(path);
			// 将图片输处到流中
			outputStream.write(file);
			// 刷新
			outputStream.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				// 关闭
				outputStream.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 序列化一个对象
	 * 
	 * @param object
	 *            要序列化的数组
	 * @return 返回存放对象序列化后信息的字节数组
	 */
	public static byte[] serialize(Object object) {
		ObjectOutputStream objectStream = null;
		ByteArrayOutputStream byteOutStream = null;
		try {
			byteOutStream = new ByteArrayOutputStream();
			objectStream = new ObjectOutputStream(byteOutStream);
			objectStream.writeObject(object);
			byte[] bytes = byteOutStream.toByteArray();
			return bytes;
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				byteOutStream.close();
				objectStream.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	/**
	 * 反序列化对象
	 * 
	 * @param bytes
	 *            对象序列化信息
	 * @return 返回反序列化后的对象
	 */
	public static Object unserialize(byte[] bytes) {
		ByteArrayInputStream byteInStream = null;
		try {
			byteInStream = new ByteArrayInputStream(bytes);
			ObjectInputStream ois = new ObjectInputStream(byteInStream);
			return ois.readObject();
		} catch (Exception e) {
		} finally {
			try {
				byteInStream.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
	}
}
